C:/Projekte/RAIS/ApplicationLogiLayer/UserManagement.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Transactions;

using RAIS.Common.DynamicMaskManagement;
using RAIS.Common.UserManagement;

using DataRoles = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.DataRole>;
using DataRoleAttributes = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.DataRoleAttribute>;  
using FunctionRoles = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole>;
using FunctionRoleCategories = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.Category>;
using FunctionRoleSubcategories = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.Subcategory>;
using Masks = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Mask>;
using Regions = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Region>;
using Districts = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.District>;
using Facilities = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Facility>;
using Practices = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Practice>;
using UserTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.UserTypeData>;
using Users = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.UserData>;
using MessageBoxRestrictions = System.Collections.Generic.List<RAIS.Common.UserManagement.MessageBoxRestriction>;

namespace RAIS.ApplicationLogicLayer
{
    public class UserManagement
    {
        #region Public static methods



        public static void InitializeDAL()
                {
                        new DataAccessLayer.UserManagement();
                }
        public static UserData GetUserData(string userName)
        {
            return DataAccessLayer.UserManagement.GetUserData(userName);    
        }

        //#-#
        public static List<UserAssignment> GetUserAssignmentsForUser(UserData user, DateTime selectedDate)
        {
            return DataAccessLayer.UserManagement.GetUserAssignmentsForUser(user, selectedDate);
        }
        public static List<UserAssignment> GetUserAssignmentsForUser(UserData user)
        {
            return DataAccessLayer.UserManagement.GetUserAssignmentsForUser(user);
        }

        //#-#
        public static List<Facility> getFacilitiesByPractice(int practiceID)
        {
            return DataAccessLayer.UserManagement.getFacilitiesByPractice(practiceID);
        }

        public static List<UserAssignment> GetUserAssignmentHistoryForUser(UserData user)
        {
            return DataAccessLayer.UserManagement.GetUserAssignmentHistoryForUser(user);
        }
                public static bool LoginUser(UserData userData)
                {
                        return RAIS.DataAccessLayer.UserManagement.LoginUser(userData);
                }
        public static bool LogoutUser(UserData userData, bool isLoggOffClick)
                {
                        return RAIS.DataAccessLayer.UserManagement.LogoutUser(userData, isLoggOffClick);
                }
                public static bool AddAccountRequest(UserData userData, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.AddAccountRequest(userData, ref returnMessage);
                }
                public static bool ReleaseAccountRequest(UserData userData, ref string returnMessage)
                {
                        if (ValidateUserDataModification(userData, ref returnMessage))
                                return RAIS.DataAccessLayer.UserManagement.ReleaseAccountRequest(userData, ref returnMessage);
                        else
                                return false;
                }
                public static bool RejectAccountRequest(UserData userData, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.RejectAccountRequest(userData, ref returnMessage);
                }
        public static bool AddUser(UserData userData, ref string returnMessage)
        {
            return  ValidateNewUserData(userData, ref returnMessage) &&
                    DataAccessLayer.UserManagement.AddUser(userData, ref returnMessage);
        }
        public static bool ModifyUser(UserData userData, ref string returnMessage)
        {
            if (ValidateUserDataModification(userData, ref returnMessage))
                return DataAccessLayer.UserManagement.ModifyUser(userData, ref returnMessage);
            else
                return false;
        }
        public static Users Users
        {
            get
            {
                Users users = DataAccessLayer.UserManagement.Users;
                //Users lockedUsers = new Users();
                                //foreach (UserData user in users.Values)
                                //{
                                //    if (user.Locked)
                                //        lockedUsers.Add(user.Login, user);
                                //}
                                //foreach (UserData lockedUser in lockedUsers.Values)
                                //{
                                //    users.Remove(lockedUser.Login);
                                //}
                return users;
            }
        }
        public static UserTypes UserTypes
        {
            get
            {
                return DataAccessLayer.UserManagement.UserTypes;
            }
        }
        public static DataRoles DataRoles
        {
            get
            {
                return DataAccessLayer.UserManagement.DataRoles;
            }
        }
        public static Practices Practices
        {
            get
            {
                return DataAccessLayer.UserManagement.Practices;
            }
        }

        public static Facilities Facilities
        {
            get
            {
                return DataAccessLayer.UserManagement.Facilities;
            }
        }
        public static Regions Regions
        {
            get
            {
                return DataAccessLayer.UserManagement.Regions;
            }
        }
        public static FunctionRoles FunctionalRoles
        {
            get
            {
                return DataAccessLayer.UserManagement.FunctionalRoles;
            }
        }
                public static FunctionRoles PredefinedFunctionalRoles
                {
                        get
                        {
                                return DataAccessLayer.UserManagement.PredefinedFunctionalRoles;
                        }
                }
        public static FunctionRoleCategories FunctionalRoleCategories
        {
            get
            {
                return DataAccessLayer.UserManagement.FunctionalRoleCategories;
            }
        }
                public static FunctionRoleCategories GetAllowCustomizationCategories()
                {
                        return DataAccessLayer.UserManagement.GetAllowCustomizationCategories();
                }
        public static FunctionRoleSubcategories GetFunctionalRoleSubcategories(FunctionRole.Category category)
        {
            return DataAccessLayer.UserManagement.GetFunctionalRoleSubcategories(category);
        }
                public static FunctionRoleSubcategories GetFunctionalRoleSubcategories(FunctionRole.Category category, bool withAll)
                {
                        return DataAccessLayer.UserManagement.GetFunctionalRoleSubcategories(category, withAll);
                }
                public static FunctionRoleSubcategories GetFunctionalRoleSubcategories(FunctionRole.Category category, bool withAll, bool showProtectors, bool showEvaluators)
                {
                        return DataAccessLayer.UserManagement.GetFunctionalRoleSubcategories(category, withAll, showProtectors, showEvaluators);
                }
        public static Masks GetMasks(FunctionRole.Category category, FunctionRole.Subcategory subcategory)
        {
            return DataAccessLayer.UserManagement.GetMasks(category, subcategory);
        }
                public static Masks GetMasksWithoutAll(FunctionRole.Category category, FunctionRole.Subcategory subcategory)
                {
                        return DataAccessLayer.UserManagement.GetMasksWithoutAll(category, subcategory, false);
                }
        public static Masks GetMasksWithoutAllWhithHidden(FunctionRole.Category category, FunctionRole.Subcategory subcategory)
        {
            return DataAccessLayer.UserManagement.GetMasksWithoutAll(category, subcategory, true);
        }
                public static Masks GetMasksWithoutAll(FunctionRole.Category category, FunctionRole.Subcategory subcategory, DynamicMask.DynamicMaskTypeData dynamicMaskType)
                {
                        return DataAccessLayer.UserManagement.GetMasksWithoutAll(category, subcategory, dynamicMaskType);
                }
                public static XmlDocument GetSiteMapByUser(UserData user, bool designMode)
        {
            return DataAccessLayer.UserManagement.GetSiteMapByUser(user, designMode);
        }
        public static void GetMaskByReference(string reference, out string CategoryID, out string SubcategoryID, out string MaskID)
        {
            DataAccessLayer.UserManagement.GetMaskByReference(reference, out CategoryID, out SubcategoryID, out MaskID);
        }
        public static Districts GetDistrictsByRegion(Region region)
        {
            if (region == null)
                return null;
            else
                return DataAccessLayer.UserManagement.GetDistrictsByRegion(region);
        }
        public static Facilities GetFacilitiesByRegionAndDistrict(Region region, District district)
        {
            if (region == null || district  == null)
                return null;
            else
                return DataAccessLayer.UserManagement.GetFacilitiesByRegionAndDistrict(region, district);
        }
        public static bool AddDataRole(string dataRoleName, ref string returnMessage)
        {
             return DataAccessLayer.UserManagement.AddDataRole(dataRoleName, ref returnMessage);
        }
        //public static Dictionary<string, DataRoleAttribute> GetDataRoleAttributes(DataRole dataRole)
        //{
        //    return DataAccessLayer.UserManagement.GetDataRoleAttributes(dataRole);
        //}
        public static bool AddDataRoleAttribute(DataRole dataRole, DataRoleAttribute dataRoleAttribute, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.AddDataRoleAttribute(dataRole, dataRoleAttribute, ref returnMessage);
        }
        public static bool RemoveDataRoleAttribute(DataRole dataRole, DataRoleAttribute dataRoleAttribute, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.RemoveDataRoleAttribute(dataRole, dataRoleAttribute, ref returnMessage);
        }
        public static bool RemoveDataRole(DataRole dataRole, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.RemoveDataRole(dataRole, ref returnMessage);
        }
        public static bool SaveDataRole(DataRole dataRole, ref string returnMessage)
        {
            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;

                foreach (DataRoleAttribute attribute in dataRole.RemovedAttributes.Values)
                {
                    if (!RemoveDataRoleAttribute(dataRole, attribute, ref returnMessage))
                    {
                        success = false;
                        break;
                    }
                }

                if (success)
                {
                    foreach (DataRoleAttribute attribute in dataRole.AddedAttributes.Values)
                    {
                        if (!AddDataRoleAttribute(dataRole, attribute, ref returnMessage))
                        {
                            success = false;
                            break;
                        }
                    }
                }
                if (success)
                {
                    success = DataAccessLayer.UserManagement.SaveDataRole(dataRole, ref returnMessage);
                }
                if (success)
                {
                    returnMessage = RAIS.Common.Messages.MODIFICATIONS_SAVED;
                    dataRole.Modified = false;
                    ts.Complete();
                }
                return success;
            }
        }
        public static bool RemoveFunctionRole(FunctionRole functionRole, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.RemoveFunctionRole(functionRole, ref returnMessage);
        }
        public static bool AddFunctionRole(string functionRoleName, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.AddFunctionRole(functionRoleName, ref returnMessage);
        }
        public static bool AddFunctionRole(string functionRoleName, FunctionRole.ValidationType validationType, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.AddFunctionRole(functionRoleName, validationType, ref returnMessage);
        }
        public static bool AddFunctionRoleAttribute(FunctionRole functionRole, FunctionRoleAttribute functionRoleAttribute, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.AddFunctionRoleAttribute(functionRole, functionRoleAttribute, ref returnMessage);
        }
        public static bool RemoveFunctionRoleAttribute(FunctionRole functionRole, FunctionRoleAttribute functionRoleAttribute, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.RemoveFunctionRoleAttribute(functionRole, functionRoleAttribute, ref returnMessage);
        }
                public static bool AddUserType(FunctionRole functionRole, UserTypeData userType, ref string returnMessage)
                {
                        return DataAccessLayer.UserManagement.AddUserType(functionRole, userType, ref returnMessage);
                }
                public static bool RemoveUserType(FunctionRole functionRole, UserTypeData userType, ref string returnMessage)
                {
                        return DataAccessLayer.UserManagement.RemoveUserType(functionRole, userType, ref returnMessage);
                }
        public static bool SaveFunctionRole(FunctionRole functionRole, ref string returnMessage)
        {
            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;

                foreach (FunctionRoleAttribute attribute in functionRole.RemovedAttributes.Values)
                {
                    if (!RemoveFunctionRoleAttribute(functionRole, attribute, ref returnMessage))
                    {
                        success = false;
                        break;
                    }
                }

                if (success)
                {
                    foreach (FunctionRoleAttribute attribute in functionRole.AddedAttributes.Values)
                    {
                        if (!AddFunctionRoleAttribute(functionRole, attribute, ref returnMessage))
                        {
                            success = false;
                            break;
                        }
                    }
                }
                                if (success)
                                {
                                        foreach (UserTypeData userType in functionRole.RemovedUserTypes.Values)
                                        {
                                                if (!RemoveUserType(functionRole, userType, ref returnMessage))
                                                {
                                                        success = false;
                                                        break;
                                                }
                                        }
                                }
                                if (success)
                                {
                                        foreach (UserTypeData userType in functionRole.AddedUserTypes.Values)
                                        {
                                                if (!AddUserType(functionRole, userType, ref returnMessage))
                                                {
                                                        success = false;
                                                        break;
                                                }
                                        }
                                }
                                if (success)
                {
                    success = DataAccessLayer.UserManagement.SaveFunctionRole(functionRole, ref returnMessage);
                }
                if (success)
                {
                    returnMessage = RAIS.Common.Messages.MODIFICATIONS_SAVED;
                    functionRole.Modified = false;
                    ts.Complete();
                }
                return success;
            }
        }
        public static bool UserExists(string userName, ref string returnMessage)
        {
            if (DataAccessLayer.UserManagement.UserExists(userName))
            {
                returnMessage = Common.Messages.USER_EXISTS_MESSAGE;
                return true;
            }
            else
            {
                return false;
            }
        }
                public static Facility GetFacilityByID(int facilityID)
                {
                        return RAIS.DataAccessLayer.UserManagement.GetFacilityByID(facilityID);
                }
                public static Department GetDepartmentByID(int departmentID)
                {
                        return RAIS.DataAccessLayer.UserManagement.GetDepartmentByID(departmentID);
                }
                public static FunctionRoles GetFunctionalRolesByUserType(UserTypeData userTypeData)
                {
                        return RAIS.DataAccessLayer.UserManagement.GetFunctionalRolesByUserType(userTypeData);
                }
                public static bool ValidateRemoveUserTypeFromFunctionRole(FunctionRole functionRole, UserTypeData userType, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.ValidateRemoveUserTypeFromFunctionRole(functionRole, userType, ref returnMessage);
                }
                public static bool AddSubcategory(FunctionRole.Subcategory subcategory, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.AddSubcategory(subcategory, ref returnMessage);
                }
                public static bool SaveSubcategory(FunctionRole.Subcategory subcategory, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.SaveSubcategory(subcategory, ref returnMessage);
                }
                public static bool SaveSubcategoryOrder(FunctionRole.Subcategory subcategory, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.SaveSubcategoryOrder(subcategory, ref returnMessage);
                }
                public static bool RemoveSubcategory(int subcategoryID, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.UserManagement.RemoveSubcategory(subcategoryID, ref returnMessage);
                }
                public static Dictionary<string, string> GetUserStatusesHistoryByUser(UserData user)
                {
                        return RAIS.DataAccessLayer.UserManagement.GetUserStatusesHistoryByUser(user);
                }
        public static void UpdateContextVisibleName(string contextName, string contextVisibleName)
        {
            DataAccessLayer.UserManagement.UpdateContextVisibleName(contextName, contextVisibleName);
        }
        public static void DeleteContext(string contextName)
        {
            DataAccessLayer.UserManagement.DeleteContext(contextName);
        }
        
        #endregion
        #region Private helper methods

        static bool ValidateNewUserData(UserData userData, ref string returnMessage)
        {
            if (DataAccessLayer.UserManagement.UserExists(userData.Login))
            {
                returnMessage = Common.Messages.USER_EXISTS_MESSAGE;
                return false;
            }
            else
            {
                returnMessage = Common.Messages.USER_ADDED;
                return ValidateUserData(userData, ref returnMessage);
            }
        }
        static bool ValidateUserDataModification(UserData userData, ref string returnMessage)
        {
            return ValidateUserData(userData, ref returnMessage);
        }
        static bool ValidateUserData(UserData userData, ref string returnMessage)
        {
            if (userData.CompleteName == null || userData.CompleteName.Length == 0)
            {
                returnMessage = Common.Messages.USER_COMPLETE_NAME_MISSING;
                return false;
            }
            else
                if (userData.Password == null || userData.Password.Length == 0)
                {
                    returnMessage = Common.Messages.USER_PASSWORD_MISSING;
                    return false;
                }
                else
                    if (userData.Email.Length == 0)
                    {
                        returnMessage = Common.Messages.USER_EMAIL_MISSING;
                        return false;
                    }
                    else
                    {
                                                if (userData.IsActive && userData.Facility == null && userData.DataRole == null)
                                                {
                                                        returnMessage = Common.Messages.USER_DATA_ROLE_FACILIY_MISSING;
                                                        return false;
                                                }
                                                else
                                                {
                                                        returnMessage = Common.Messages.USER_DETAILS_SAVED;
                                                        return true;
                                                }
                    }
        }
        #endregion

        // #-# 
        public static MessageBoxRestrictions getActiveMessageBoxRestrictionsForUser(UserData user)
        {
            return DataAccessLayer.UserManagement.getActiveMessageBoxRestrictionsForUser(user);
        }
        public static MessageBoxRestrictions getActiveMessageBoxRestrictionsForUser(UserData user, DateTime selectedDate)
        {
            return DataAccessLayer.UserManagement.getActiveMessageBoxRestrictionsForUser(user, selectedDate);
        }

        /*
         * #+#
         */
        public static DataRole getMessageBoxDataRoleByUser(UserData user)
        {
            return DataAccessLayer.UserManagement.getMessageBoxDataRoleByUser(user);
        }
        /* */

        public static DataRole getMessageBoxDataRoleByUserAndDate(UserData user, DateTime date)
        {
            return DataAccessLayer.UserManagement.getMessageBoxDataRoleByUserAndDate(user, date);
        }

        public static List<UserData> GetUserFreeToTakeOver()
        {
            return DataAccessLayer.UserManagement.GetUserFreeToTakeOver();
        }

        public static bool clearTakeOverForUser(UserData user)
        {
            return DataAccessLayer.UserManagement.clearTakeOverForUser(user);
        }

        //#-#
        public static bool saveMessageboxRestriction(UserData user, MessageBoxRestriction newMbr, ref string returnMessage)
        {

            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;

                if (success)
                {
                    success = RAIS.DataAccessLayer.UserManagement.saveMessageboxRestriction(user, newMbr, ref returnMessage);
                }
                if (success)
                {
                    ts.Complete();
                }
                return success;
            }
        }


        public static bool editMessageboxRestriction(UserData user, MessageBoxRestriction mbr, ref string returnMessage)
        {

            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;

                if (success)
                {
                    success = RAIS.DataAccessLayer.UserManagement.editMessageboxRestriction(user, mbr, ref returnMessage);
                }
                if (success)
                {
                    ts.Complete();
                }
                return success;
            }
        }

        public static bool deleteMessageboxRestriction(UserData user, MessageBoxRestriction mbr, ref string returnMessage)
        {

            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;

                if (success)
                {
                    success = RAIS.DataAccessLayer.UserManagement.deleteMessageboxRestriction(user, mbr, ref returnMessage);
                }
                if (success)
                {
                    ts.Complete();
                }
                return success;
            }
        }

        public static List<MessageBoxRestriction> MessageboxRestrictionHistoryForUser(UserData user, ref string returnMessage)
        {
            return DataAccessLayer.UserManagement.MessageboxRestrictionHistoryForUser(user, ref returnMessage);
        }


        public static Users GetLevelThreeUsers()
        {
            return DataAccessLayer.UserManagement.GetLevelThreeUsers();
        }

        //#-#
        public static bool createUserAssignmentForUser(UserAssignment ua, UserData ud, ref string outputMessage)
        {
            return DataAccessLayer.UserManagement.createUserAssignmentForUser(ua, ud, ref outputMessage);
        }

        //#-#
        public static bool editUserAssignment(UserAssignment ua, ref string outputMessage)
        {
            return DataAccessLayer.UserManagement.editUserAssignment(ua, ref outputMessage);
        }

        //#-#
        public static bool deleteUserAssignment(UserAssignment ua, ref string outputMessage)
        {
            return DataAccessLayer.UserManagement.deleteUserAssignment(ua, ref outputMessage);
        }

    }
}